package com.zudada.servermain.Service.ServiceImpl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zudada.servermain.POJO.DTO.PortAddDTO;
import com.zudada.servermain.POJO.DTO.PortBasicUpdateDTO;
import com.zudada.servermain.POJO.DTO.PortQueryDTO;
import com.zudada.servermain.POJO.VO.PortVO;
import com.zudada.servermain.POJO.entity.PortBasic;
import com.zudada.servermain.Service.PortBasicService;
import com.zudada.servermain.exception.BusinessException;
import com.zudada.servermain.mapper.PortBasicMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
@Slf4j
public class PortBasicServiceImpl extends ServiceImpl<PortBasicMapper, PortBasic> implements PortBasicService {

    /**
     * 新增港口
     * @param portAddDTO 港口信息实体
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void savePort(PortAddDTO portAddDTO) {
        // 业务校验：港口ID不能为空（DTO层已通过@NotBlank验证，此处作为双重保障）
        if (!StringUtils.hasText(portAddDTO.getPortId())) {
            throw new BusinessException("港口ID不能为空");
        }

        // 业务校验：港口名称不能为空
        if (portAddDTO.getPortName() == null || portAddDTO.getPortName().trim().isEmpty()) {
            throw new BusinessException("港口名称不能为空");
        }

        // 业务校验：位置格式验证（DTO层已通过@Pattern验证，此处作为双重保障）
        if (StringUtils.hasText(portAddDTO.getLocation())) {
            String location = portAddDTO.getLocation().trim();
            if (!location.matches("^\\(-?\\d+(\\.\\d+)?,-?\\d+(\\.\\d+)?\\)$")) {
                throw new BusinessException("位置格式不正确，应为(经度,纬度)格式，例如：(121.6144,38.9138) 或 (100,100)");
            }
        }

        // 业务校验：状态只能是"正常"或"维护中"（DTO层已通过@Pattern验证，此处作为双重保障）
        if (StringUtils.hasText(portAddDTO.getStatus())) {
            String status = portAddDTO.getStatus().trim();
            if (!status.equals("正常") && !status.equals("维护中")) {
                throw new BusinessException("状态只能是'正常'或'维护中'");
            }
        }

        PortBasic portBasic = new PortBasic();
        BeanUtils.copyProperties(portAddDTO, portBasic);

        // 补充默认值：创建时间、更新时间、状态默认"正常"
        Date now = new Date();
        portBasic.setCreateTime(now);
        portBasic.setUpdateTime(now);
        if (!StringUtils.hasText(portBasic.getStatus())) {
            portBasic.setStatus("正常");
        }

        // 调用Mapper保存数据
        this.save(portBasic);
    }

    /**
     * 根据id删除港口
     * @param id 港口ID
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delPort(String id) {
        // 判断是否为空
        if (!StringUtils.hasText(id)) {
            throw new BusinessException("港口ID不能为空");
        }

        // 判断id是否存在
        PortBasic portBasic = this.getById(id);
        if (portBasic == null) {
            throw new BusinessException("港口不存在，ID: " + id);
        }

        // 执行删除操作
        boolean result = this.removeById(id);
        if (!result) {
            throw new BusinessException("删除港口失败，ID: " + id);
        }
    }
    /**
     * 条件查询港口数据
     * @param queryDTO 查询条件
     * @return 港口VO列表
     */
    @Override
    public List<PortVO> listPorts(PortQueryDTO queryDTO) {
        LambdaQueryWrapper<PortBasic> queryWrapper = new LambdaQueryWrapper<>();
        if (queryDTO.getPortId() != null && !queryDTO.getPortId().isEmpty()) {
            queryWrapper.eq(PortBasic::getPortId, queryDTO.getPortId());
        }
        if (queryDTO.getPortName() != null && !queryDTO.getPortName().isEmpty()) {
            queryWrapper.like(PortBasic::getPortName, queryDTO.getPortName());
        }
        if (queryDTO.getRegion() != null && !queryDTO.getRegion().isEmpty()) {
            queryWrapper.eq(PortBasic::getRegion, queryDTO.getRegion());
        }
        if (queryDTO.getStatus() != null && !queryDTO.getStatus().isEmpty()) {
            queryWrapper.eq(PortBasic::getStatus, queryDTO.getStatus());
        }

        List<PortBasic> portBasicList = this.list(queryWrapper);

        // 遍历实体列表，逐个转换为VO对象
        return portBasicList.stream()
                .map(this::convertToVO)  // 调用转换方法
                .collect(Collectors.toList());  // 收集为VO列表
    }

    /**
     * 修改港口数据
     * @param dto
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updatePort(PortBasicUpdateDTO dto) {


        // 校验港口ID
        if (!StringUtils.hasText(dto.getPortId())) {
            throw new BusinessException("港口ID不能为空");
        }

        // 判断港口是否存在
        PortBasic existingPort = this.getById(dto.getPortId());
        if (existingPort == null) {
            throw new BusinessException("港口不存在，ID: " + dto.getPortId());
        }
        // 业务校验：位置格式验证（DTO层已通过@Pattern验证，此处作为双重保障）
        if (StringUtils.hasText(dto.getLocation())) {
            String location = dto.getLocation().trim();
            if (!location.matches("^\\(-?\\d+(\\.\\d+)?,-?\\d+(\\.\\d+)?\\)$")) {
                throw new BusinessException("位置格式不正确，应为(经度,纬度)格式，例如：(121.6144,38.9138) 或 (100,100)");
            }
        }

        // 业务校验：状态只能是"正常"或"维护中"（DTO层已通过@Pattern验证，此处作为双重保障）
        if (StringUtils.hasText(dto.getStatus())) {
            String status = dto.getStatus().trim();
            if (!status.equals("正常") && !status.equals("维护中")) {
                throw new BusinessException("状态只能是'正常'或'维护中'");
            }
        }


        // 构建更新的实体对象
        PortBasic portBasic = new PortBasic();
        portBasic.setPortId(dto.getPortId());
        if (StringUtils.hasText(dto.getPortName())) {
            portBasic.setPortName(dto.getPortName());
        }
        if (StringUtils.hasText(dto.getRegion())) {
            portBasic.setRegion(dto.getRegion());
        }
        if (StringUtils.hasText(dto.getLocation())) {
            portBasic.setLocation(dto.getLocation());
        }
        if (StringUtils.hasText(dto.getPortType())) {
            portBasic.setPortType(dto.getPortType());
        }
        if (StringUtils.hasText(dto.getStatus())) {
            portBasic.setStatus(dto.getStatus());
        }
        portBasic.setUpdateTime(new Date());

        // 执行更新操作
        this.updateById(portBasic);
    }


    /**
     * 单个实体转VO的工具方法
     * @param portBasic 港口实体
     * @return 港口VO对象
     */
    private PortVO convertToVO(PortBasic portBasic) {
        if (portBasic == null) {
            return null;  // 空值保护，避免空指针异常
        }
        PortVO vo = new PortVO();
        // 拷贝同名同类型的属性
        BeanUtils.copyProperties(portBasic, vo);
        return vo;
    }
}